டைப்ஸ்கிரிப்ட் மிடில்வேர்: எக்ஸ்பிரஸ் மிடில்வேர் வகை வடிவங்களை மாஸ்டரிங் செய்தல்

எக்ஸ்பிரஸ்.ஜேஎஸ் (Express.js), ஒரு குறைந்தபட்ச மற்றும் நெகிழ்வான Node.js வலை பயன்பாட்டு கட்டமைப்பு ஆகும், இது டெவலப்பர்களை உறுதியான மற்றும் அளவிடக்கூடிய APIகள் மற்றும் வலை பயன்பாடுகளை உருவாக்க அனுமதிக்கிறது. டைப்ஸ்கிரிப்ட் (TypeScript) நிலையான தட்டச்சு (static typing) சேர்ப்பதன் மூலமும், குறியீடு பராமரிப்பை மேம்படுத்துவதன் மூலமும், பிழைகளை முன்னதாகவே கண்டறிவதன் மூலமும் எக்ஸ்பிரஸை மேம்படுத்துகிறது. மிடில்வேர் செயல்பாடுகள் (Middleware functions) எக்ஸ்பிரஸின் ஒரு மூலக்கல்லாகும், இது உங்கள் ரூட் ஹேண்ட்லர்களை (route handlers) அடைவதற்கு முன்பு கோரிக்கைகளை இடைமறித்து செயலாக்க உங்களை செயல்படுத்துகிறது. இந்த கட்டுரை எக்ஸ்பிரஸ் மிடில்வேரை வரையறுப்பதற்கும் பயன்படுத்துவதற்கும் மேம்பட்ட டைப்ஸ்கிரிப்ட் வகை வடிவங்களை ஆராய்கிறது, இது வகை பாதுகாப்பையும் (type safety) குறியீடு தெளிவையும் மேம்படுத்துகிறது.

எக்ஸ்பிரஸ் மிடில்வேரை புரிந்துகொள்ளுதல்

மிடில்வேர் செயல்பாடுகள் (Middleware functions) என்பவை, கோரிக்கை பொருள் (req), பதில் பொருள் (res), மற்றும் பயன்பாட்டின் கோரிக்கை-பதில் சுழற்சியில் (request-response cycle) அடுத்த மிடில்வேர் செயல்பாடு (next middleware function) ஆகியவற்றை அணுகக்கூடிய செயல்பாடுகள் ஆகும். மிடில்வேர் செயல்பாடுகள் பின்வரும் பணிகளைச் செய்ய முடியும்:

• எந்தவொரு குறியீட்டையும் செயல்படுத்துதல்.
• கோரிக்கை மற்றும் பதில் பொருட்களை மாற்றுதல்.
• கோரிக்கை-பதில் சுழற்சியை முடித்தல்.
• அடுக்கில் உள்ள அடுத்த மிடில்வேர் செயல்பாட்டை அழைத்தல்.

மிடில்வேர் செயல்பாடுகள் எக்ஸ்பிரஸ் பயன்பாட்டில் சேர்க்கப்படும்போது வரிசையாக செயல்படுத்தப்படுகின்றன. மிடில்வேருக்கான பொதுவான பயன்பாட்டு நிகழ்வுகள் பின்வருமாறு:

• கோரிக்கைகளை பதிவு செய்தல்.
• பயனர்களை அங்கீகரித்தல்.
• வளங்களுக்கான அணுகலை அங்கீகரித்தல்.
• கோரிக்கை தரவை சரிபார்த்தல்.
• பிழைகளை கையாளுதல்.

அடிப்படை டைப்ஸ்கிரிப்ட் மிடில்வேர்

அடிப்படை டைப்ஸ்கிரிப்ட் எக்ஸ்பிரஸ் பயன்பாட்டில், ஒரு மிடில்வேர் செயல்பாடு இப்படி இருக்கும்:

            
import { Request, Response, NextFunction } from 'express';

function loggerMiddleware(req: Request, res: Response, next: NextFunction) {
  console.log(`Request: ${req.method} ${req.url}`);
  next();
}

export default loggerMiddleware;

            

              
                Copy
              
            
          

இந்த எளிய மிடில்வேர், கோரிக்கை முறை மற்றும் URL ஐ கன்சோலில் பதிவு செய்கிறது. வகை விளக்கங்களை (type annotations) விரிவாகப் பார்ப்போம்:

• Request: எக்ஸ்பிரஸ் கோரிக்கை பொருளைக் (request object) குறிக்கிறது.
• Response: எக்ஸ்பிரஸ் பதில் பொருளைக் (response object) குறிக்கிறது.
• NextFunction: ஒரு செயல்பாடு, செயல்படுத்தப்படும்போது, அடுக்கில் உள்ள அடுத்த மிடில்வேரை செயல்படுத்துகிறது.

இந்த மிடில்வேரை உங்கள் எக்ஸ்பிரஸ் பயன்பாட்டில் இப்படிப் பயன்படுத்தலாம்:

            
import express from 'express';
import loggerMiddleware from './middleware/loggerMiddleware';

const app = express();
const port = 3000;

app.use(loggerMiddleware);

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

மிடில்வேருக்கான மேம்பட்ட வகை வடிவங்கள்

அடிப்படை மிடில்வேர் எடுத்துக்காட்டு செயல்படும் என்றாலும், இது மிகவும் சிக்கலான சூழ்நிலைகளுக்கு நெகிழ்வுத்தன்மை மற்றும் வகை பாதுகாப்பு ஆகியவற்றில் குறைபாடுகளைக் கொண்டுள்ளது. டைப்ஸ்கிரிப்ட் (TypeScript) மூலம் மிடில்வேர் மேம்பாட்டை மேம்படுத்தும் மேம்பட்ட வகை வடிவங்களை (advanced type patterns) ஆராய்வோம்.

1. தனிப்பயன் கோரிக்கை/பதில் வகைகள்

அடிக்கடி, நீங்கள் Request அல்லது Response பொருட்களை தனிப்பயன் பண்புகளுடன் (custom properties) நீட்டிக்க வேண்டியிருக்கும். உதாரணமாக, அங்கீகாரத்திற்குப் பிறகு, நீங்கள் ஒரு user பண்பை Request பொருளில் சேர்க்க விரும்பலாம். டைப்ஸ்கிரிப்ட் (TypeScript) ஆனது அறிவிப்பு ஒன்றிணைப்பைப் (declaration merging) பயன்படுத்தி இருக்கும் வகைகளை (existing types) அதிகரிக்க உங்களை அனுமதிக்கிறது.

            
// src/types/express/index.d.ts
import { Request as ExpressRequest } from 'express';

declare global {
  namespace Express {
    interface Request {
      user?: {
        id: string;
        email: string;
        // ... other user properties
      };
    }
  }
}

export {}; // This is needed to make the file a module

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், நாம் Express.Request இன்டர்ஃபேஸை ஒரு விருப்பமான user பண்பைச் சேர்க்க அதிகரிக்கிறோம். இப்போது, உங்கள் அங்கீகார மிடில்வேரில் (authentication middleware), நீங்கள் இந்தப் பண்பை நிரப்பலாம்:

            
import { Request, Response, NextFunction } from 'express';

function authenticationMiddleware(req: Request, res: Response, next: NextFunction) {
  // Simulate authentication logic
  const userId = req.headers['x-user-id'] as string; // Or fetch from a token, etc.

  if (userId) {
    // In a real application, you would fetch the user from a database
    req.user = {
      id: userId,
      email: `user${userId}@example.com`
    };
    next();
  } else {
    res.status(401).send('Unauthorized');
  }
}

export default authenticationMiddleware;

            

              
                Copy
              
            
          

மேலும் உங்கள் ரூட் ஹேண்ட்லர்களில் (route handlers), நீங்கள் req.user பண்பை பாதுகாப்பாக அணுகலாம்:

            
import express from 'express';
import authenticationMiddleware from './middleware/authenticationMiddleware';

const app = express();
const port = 3000;

app.use(authenticationMiddleware);

app.get('/profile', (req: Request, res: Response) => {
  if (req.user) {
    res.send(`Hello, ${req.user.email}! Your user ID is ${req.user.id}`);
  } else {
    // This should never happen if the middleware is working correctly
    res.status(500).send('Internal Server Error');
  }
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

2. மிடில்வேர் தொழிற்சாலைகள்

மிடில்வேர் தொழிற்சாலைகள் (Middleware factories) என்பவை மிடில்வேர் செயல்பாடுகளைத் திரும்பப் பெறும் செயல்பாடுகள் ஆகும். குறிப்பிட்ட விருப்பங்கள் அல்லது சார்புநிலைகளுடன் (options or dependencies) மிடில்வேரை உள்ளமைக்க (configure) வேண்டியிருக்கும் போது இந்த முறை பயனுள்ளதாக இருக்கும். உதாரணமாக, குறிப்பிட்ட கோப்பில் செய்திகளைப் பதிவு செய்யும் ஒரு பதிவு மிடில்வேரை (logging middleware) கருத்தில் கொள்ளுங்கள்:

            
import { Request, Response, NextFunction } from 'express';
import fs from 'fs';
import path from 'path';

function createLoggingMiddleware(logFilePath: string) {
  return (req: Request, res: Response, next: NextFunction) => {
    const logMessage = `[${new Date().toISOString()}] Request: ${req.method} ${req.url}\n`;
    fs.appendFile(logFilePath, logMessage, (err) => {
      if (err) {
        console.error('Error writing to log file:', err);
      }      next();
    });
  };
}

export default createLoggingMiddleware;

            

              
                Copy
              
            
          

இந்த மிடில்வேர் தொழிற்சாலையை (middleware factory) நீங்கள் இப்படிப் பயன்படுத்தலாம்:

            
import express from 'express';
import createLoggingMiddleware from './middleware/loggingMiddleware';

const app = express();
const port = 3000;

const logFilePath = path.join(__dirname, 'logs', 'requests.log');
app.use(createLoggingMiddleware(logFilePath));

app.get('/', (req, res) => {
  res.send('Hello, world!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

3. ஒத்திசைவற்ற மிடில்வேர்

மிடில்வேர் செயல்பாடுகள் (Middleware functions) பெரும்பாலும் தரவுத்தள வினவல்கள் (database queries) அல்லது API அழைப்புகள் போன்ற ஒத்திசைவற்ற செயல்பாடுகளை (asynchronous operations) செய்ய வேண்டும். ஒத்திசைவற்ற செயல்பாடுகளைச் சரியாகக் கையாள, ஒத்திசைவற்ற செயல்பாடு முடிந்த பிறகு next செயல்பாடு அழைக்கப்படுவதை நீங்கள் உறுதிப்படுத்த வேண்டும். இதை async/await அல்லது Promises ஐப் பயன்படுத்தி அடையலாம்.

            
import { Request, Response, NextFunction } from 'express';

async function asyncMiddleware(req: Request, res: Response, next: NextFunction) {
  try {
    // Simulate an asynchronous operation
    await new Promise(resolve => setTimeout(resolve, 100));
    console.log('Asynchronous operation completed');
    next();
  } catch (error) {
    next(error); // Pass the error to the error handling middleware
  }
}

export default asyncMiddleware;

            

              
                Copy
              
            
          

முக்கியம்: உங்கள் ஒத்திசைவற்ற மிடில்வேரில் (asynchronous middleware) பிழைகளைக் கையாளவும், அவற்றை next(error) ஐப் பயன்படுத்தி பிழை கையாளுதல் மிடில்வேருக்கு (error handling middleware) அனுப்பவும் நினைவில் கொள்ளுங்கள். இது பிழைகள் சரியாகக் கையாளப்பட்டு பதிவு செய்யப்படுவதை உறுதி செய்கிறது.

4. பிழை கையாளுதல் மிடில்வேர்

பிழை கையாளுதல் மிடில்வேர் (Error handling middleware) என்பது கோரிக்கை-பதில் சுழற்சியின் போது ஏற்படும் பிழைகளைக் கையாளும் ஒரு சிறப்பு வகை மிடில்வேர் ஆகும். பிழை கையாளுதல் மிடில்வேர் செயல்பாடுகள் நான்கு ஆர்க்யூமென்ட்களைக் கொண்டுள்ளன: err, req, res, மற்றும் next.

            
import { Request, Response, NextFunction } from 'express';

function errorHandler(err: any, req: Request, res: Response, next: NextFunction) {
  console.error(err.stack);
  res.status(500).send('Something went wrong!');
}

export default errorHandler;

            

              
                Copy
              
            
          

நீங்கள் பிழை கையாளுதல் மிடில்வேரை (error handling middleware) மற்ற அனைத்து மிடில்வேர் மற்றும் ரூட் ஹேண்ட்லர்களுக்குப் பிறகு பதிவு செய்ய வேண்டும். எக்ஸ்பிரஸ் (Express) நான்கு ஆர்க்யூமென்ட்களின் இருப்பைக் கொண்டு பிழை கையாளுதல் மிடில்வேரை அடையாளம் காண்கிறது.

            
import express from 'express';
import asyncMiddleware from './middleware/asyncMiddleware';
import errorHandler from './middleware/errorHandler';

const app = express();
const port = 3000;

app.use(asyncMiddleware);

app.get('/', (req, res) => {
  throw new Error('Simulated error!'); // Simulate an error
});

app.use(errorHandler); // Error handling middleware MUST be registered last

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

5. கோரிக்கை சரிபார்ப்பு மிடில்வேர்

கோரிக்கை சரிபார்ப்பு (Request validation) என்பது பாதுகாப்பான மற்றும் நம்பகமான APIகளை உருவாக்குவதில் ஒரு முக்கியமான அம்சமாகும். உள்வரும் கோரிக்கை தரவை சரிபார்க்கவும், அது உங்கள் ரூட் ஹேண்ட்லர்களை (route handlers) அடைவதற்கு முன்பு சில அளவுகோல்களை பூர்த்தி செய்கிறது என்பதை உறுதிப்படுத்தவும் மிடில்வேர் (Middleware) பயன்படுத்தப்படலாம். joi அல்லது express-validator போன்ற நூலகங்கள் கோரிக்கை சரிபார்ப்புக்குப் பயன்படுத்தப்படலாம்.

express-validator ஐப் பயன்படுத்தி ஒரு எடுத்துக்காட்டு இங்கே:

            
import { Request, Response, NextFunction } from 'express';
import { body, validationResult } from 'express-validator';

const validateCreateUserRequest = [
  body('email').isEmail().normalizeEmail(),
  body('password').isLength({ min: 8 }),
  (req: Request, res: Response, next: NextFunction) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }
    next();
  }
];

export default validateCreateUserRequest;

            

              
                Copy
              
            
          

இந்த மிடில்வேர் (middleware) கோரிக்கை உடலில் உள்ள (request body) email மற்றும் password புலங்களைச் சரிபார்க்கிறது. சரிபார்ப்பு தோல்வியுற்றால், அது பிழை செய்திகளின் வரிசையுடன் 400 Bad Request பதிலை வழங்குகிறது. இந்த மிடில்வேரை உங்கள் ரூட் ஹேண்ட்லர்களில் (route handlers) இப்படிப் பயன்படுத்தலாம்:

            
import express from 'express';
import validateCreateUserRequest from './middleware/validateCreateUserRequest';

const app = express();
const port = 3000;

app.post('/users', validateCreateUserRequest, (req, res) => {
  // If validation passes, create the user
  res.send('User created successfully!');
});

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

6. மிடில்வேருக்கான சார்புநிலை செலுத்தீடு

உங்கள் மிடில்வேர் செயல்பாடுகள் (middleware functions) வெளிப்புற சேவைகள் அல்லது உள்ளமைவுகளை (configurations) சார்ந்திருக்கும் போது, சார்புநிலை செலுத்தீடு (dependency injection) சோதனைத்தன்மை (testability) மற்றும் பராமரிப்புத்தன்மையை (maintainability) மேம்படுத்த உதவும். நீங்கள் tsyringe போன்ற ஒரு சார்புநிலை செலுத்தீடு கொள்கலனைப் (dependency injection container) பயன்படுத்தலாம் அல்லது உங்கள் மிடில்வேர் தொழிற்சாலைகளுக்கு (middleware factories) சார்புநிலைகளை ஆர்க்யூமென்ட்களாக அனுப்பலாம்.

சார்புநிலை செலுத்தீடுடன் (dependency injection) ஒரு மிடில்வேர் தொழிற்சாலையைப் (middleware factory) பயன்படுத்தும் ஒரு எடுத்துக்காட்டு இங்கே:

            
// src/services/UserService.ts
export class UserService {
  async createUser(email: string, password: string): Promise {
    // In a real application, you would save the user to a database
    console.log(`Creating user with email: ${email} and password: ${password}`);
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate a database operation
  }
}

            

              
                Copy
              
            
          

            
// src/middleware/createUserMiddleware.ts
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/UserService';

function createCreateUserMiddleware(userService: UserService) {
  return async (req: Request, res: Response, next: NextFunction) => {
    try {
      const { email, password } = req.body;
      await userService.createUser(email, password);
      res.status(201).send('User created successfully!');
    } catch (error) {
      next(error);
    }
  };
}

export default createCreateUserMiddleware;

            

              
                Copy
              
            
          

            
// src/app.ts
import express from 'express';
import createCreateUserMiddleware from './middleware/createUserMiddleware';
import { UserService } from './services/UserService';
import errorHandler from './middleware/errorHandler';

const app = express();
const port = 3000;

app.use(express.json()); // Parse JSON request bodies

const userService = new UserService();
const createUserMiddleware = createCreateUserMiddleware(userService);

app.post('/users', createUserMiddleware);

app.use(errorHandler);

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

            

              
                Copy
              
            
          

டைப்ஸ்கிரிப்ட் மிடில்வேருக்கான சிறந்த நடைமுறைகள்

• மிடில்வேர் செயல்பாடுகளைச் சிறியதாகவும், கவனம் கொண்டதாகவும் வைத்திருங்கள். ஒவ்வொரு மிடில்வேர் செயல்பாட்டிற்கும் ஒரு ஒற்றை பொறுப்பு இருக்க வேண்டும்.
• உங்கள் மிடில்வேர் செயல்பாடுகளுக்கு விளக்கமான பெயர்களைப் பயன்படுத்துங்கள். பெயர் மிடில்வேர் என்ன செய்கிறது என்பதைத் தெளிவாகக் குறிக்க வேண்டும்.
• பிழைகளைச் சரியாகக் கையாளவும். எப்போதும் பிழைகளைக் கண்டறிந்து, next(error) ஐப் பயன்படுத்தி பிழை கையாளுதல் மிடில்வேருக்கு அனுப்பவும்.
• வகை பாதுகாப்பை (type safety) மேம்படுத்த தனிப்பயன் கோரிக்கை/பதில் வகைகளைப் (custom request/response types) பயன்படுத்தவும். தேவைக்கேற்ப Request மற்றும் Response இடைமுகங்களை தனிப்பயன் பண்புகளுடன் (custom properties) அதிகரிக்கவும்.
• குறிப்பிட்ட விருப்பங்களுடன் மிடில்வேரை உள்ளமைக்க மிடில்வேர் தொழிற்சாலைகளைப் (middleware factories) பயன்படுத்தவும்.
• உங்கள் மிடில்வேர் செயல்பாடுகளை ஆவணப்படுத்துங்கள். மிடில்வேர் என்ன செய்கிறது என்பதையும் அதை எப்படிப் பயன்படுத்த வேண்டும் என்பதையும் விளக்குங்கள்.
• உங்கள் மிடில்வேர் செயல்பாடுகளை முழுமையாகச் சோதிக்கவும். உங்கள் மிடில்வேர் செயல்பாடுகள் சரியாகச் செயல்படுகின்றன என்பதை உறுதிப்படுத்த அலகு சோதனைகளை (unit tests) எழுதுங்கள்.

முடிவுரை

டைப்ஸ்கிரிப்ட் (TypeScript) நிலையான தட்டச்சு (static typing) சேர்ப்பதன் மூலமும், குறியீடு பராமரிப்பை மேம்படுத்துவதன் மூலமும், பிழைகளை முன்னதாகவே கண்டறிவதன் மூலமும் எக்ஸ்பிரஸ் மிடில்வேர் (Express middleware) மேம்பாட்டை கணிசமாக மேம்படுத்துகிறது. தனிப்பயன் கோரிக்கை/பதில் வகைகள் (custom request/response types), மிடில்வேர் தொழிற்சாலைகள் (middleware factories), ஒத்திசைவற்ற மிடில்வேர் (asynchronous middleware), பிழை கையாளுதல் மிடில்வேர் (error handling middleware), மற்றும் கோரிக்கை சரிபார்ப்பு மிடில்வேர் (request validation middleware) போன்ற மேம்பட்ட வகை வடிவங்களை (advanced type patterns) மாஸ்டரிங் செய்வதன் மூலம், நீங்கள் உறுதியான, அளவிடக்கூடிய மற்றும் வகை-பாதுகாப்பான எக்ஸ்பிரஸ் பயன்பாடுகளை (Express applications) உருவாக்கலாம். உங்கள் மிடில்வேர் செயல்பாடுகளைச் சிறியதாகவும், கவனம் கொண்டதாகவும், நன்கு ஆவணப்படுத்தப்பட்டதாகவும் வைத்திருக்க சிறந்த நடைமுறைகளைப் (best practices) பின்பற்ற நினைவில் கொள்ளுங்கள்.